// utils/auth.js - 用户认证相关工具函数
import { request } from './request.js';

/**
 * 设置用户信息到本地存储
 * @param {Object} userData 用户数据
 */
export function setUserInfo(userData) {
  try {
    // 保存token
    if (userData.token) {
      uni.setStorageSync('token', `Bearer ${userData.token}`);
    }
    
    // 保存用户信息
    const userInfo = {
      id: userData.user?.id || userData.id,
      userName: userData.user?.userName || userData.userName || userData.username,
      avatar: userData.user?.avatar || userData.avatar,
      phone: userData.user?.phone || userData.phone,
      email: userData.user?.email || userData.email,
      gender: userData.user?.gender || userData.gender,
      birthday: userData.user?.birthday || userData.birthday,
      registerTime: userData.user?.registerTime || userData.registerTime,
      lastLoginTime: userData.user?.lastLoginTime || userData.lastLoginTime,
      status: userData.user?.status || userData.status
    };
    
    uni.setStorageSync('userInfo', userInfo);
    uni.setStorageSync('isLoggedIn', true);
    
    console.log('用户信息保存成功:', userInfo);
    return Promise.resolve(userInfo);
  } catch (error) {
    console.error('保存用户信息失败:', error);
    return Promise.reject(error);
  }
}

/**
 * 获取本地存储的用户信息
 * @returns {Object|null} 用户信息
 */
export function getUserInfo() {
  try {
    const userInfo = uni.getStorageSync('userInfo');
    const isLoggedIn = uni.getStorageSync('isLoggedIn');
    
    if (isLoggedIn && userInfo) {
      return userInfo;
    }
    return null;
  } catch (error) {
    console.error('获取用户信息失败:', error);
    return null;
  }
}

/**
 * 获取Token
 * @returns {string} token字符串
 */
export function getToken() {
  try {
    return uni.getStorageSync('token') || '';
  } catch (error) {
    console.error('获取Token失败:', error);
    return '';
  }
}

/**
 * 检查是否已登录
 * @returns {boolean} 是否已登录
 */
export function isLoggedIn() {
  try {
    const token = getToken();
    const userInfo = getUserInfo();
    const loginStatus = uni.getStorageSync('isLoggedIn');
    
    return !!(token && userInfo && loginStatus);
  } catch (error) {
    console.error('检查登录状态失败:', error);
    return false;
  }
}

/**
 * 清除用户信息，退出登录
 */
export function clearUserInfo() {
  try {
    uni.removeStorageSync('token');
    uni.removeStorageSync('userInfo');
    uni.removeStorageSync('isLoggedIn');
    
    console.log('用户信息清除成功');
  } catch (error) {
    console.error('清除用户信息失败:', error);
  }
}

/**
 * 更新用户信息
 * @param {Object} newUserInfo 新的用户信息
 */
export function updateUserInfo(newUserInfo) {
  try {
    const currentUserInfo = getUserInfo();
    if (currentUserInfo) {
      const updatedUserInfo = { ...currentUserInfo, ...newUserInfo };
      uni.setStorageSync('userInfo', updatedUserInfo);
      return updatedUserInfo;
    }
    return null;
  } catch (error) {
    console.error('更新用户信息失败:', error);
    return null;
  }
}

/**
 * 刷新用户Token
 * @returns {Promise} 刷新结果
 */
export async function refreshToken() {
  try {
    const response = await request({
      url: '/api/user/refresh-token',
      method: 'POST',
      showLoading: false
    });
    
    if (response.success && response.data && response.data.token) {
      uni.setStorageSync('token', `Bearer ${response.data.token}`);
      return response.data;
    } else {
      throw new Error('Token刷新失败');
    }
  } catch (error) {
    console.error('刷新Token失败:', error);
    // Token刷新失败，清除用户信息并跳转到登录页
    clearUserInfo();
    uni.reLaunch({
      url: '/pages/login/index'
    });
    throw error;
  }
}

/**
 * 获取当前用户详细信息（从服务器）
 * @returns {Promise} 用户信息
 */
export async function fetchUserProfile() {
  try {
    const response = await request({
      url: '/api/user/profile',
      method: 'GET',
      showLoading: false
    });
    
    // 检查响应格式 - 后端返回的格式是 {code: 200, data: {...}, message: "..."}
    if ((response.code === 200 || response.success) && response.data) {
      // 更新本地用户信息
      updateUserInfo(response.data);
      return response.data;
    } else {
      throw new Error(response.message || '获取用户信息失败');
    }
  } catch (error) {
    console.error('获取用户信息失败:', error);
    
    // 如果是401错误，表示token过期
    if (error.status === 401) {
      try {
        await refreshToken();
        // 重试获取用户信息
        return await fetchUserProfile();
      } catch (refreshError) {
        console.error('Token刷新失败:', refreshError);
        throw refreshError;
      }
    }
    
    throw error;
  }
}

/**
 * 登录检查中间件
 * 用于页面onLoad时检查登录状态
 * @param {Object} options 页面参数
 * @param {boolean} requireLogin 是否需要登录
 * @returns {boolean} 是否已登录
 */
export function checkLoginStatus(options = {}, requireLogin = false) {
  const loginStatus = isLoggedIn();
  
  if (requireLogin && !loginStatus) {
    // 需要登录但未登录，跳转到登录页
    uni.showToast({
      title: '请先登录',
      icon: 'none'
    });
    
    setTimeout(() => {
      uni.navigateTo({
        url: '/pages/login/index'
      });
    }, 1500);
    
    return false;
  }
  
  return loginStatus;
}

/**
 * 退出登录
 */
export function logout() {
  try {
    // 清除本地存储的用户信息
    clearUserInfo();
    
    // 显示退出成功提示
    uni.showToast({
      title: '退出成功',
      icon: 'success'
    });
    
    // 跳转到登录页
    setTimeout(() => {
      uni.reLaunch({
        url: '/pages/login/index'
      });
    }, 1000);
    
  } catch (error) {
    console.error('退出登录失败:', error);
    uni.showToast({
      title: '退出失败',
      icon: 'none'
    });
  }
}

/**
 * 验证Token是否有效
 * @returns {Promise<boolean>} Token是否有效
 */
export async function validateToken() {
  try {
    const token = getToken();
    if (!token) {
      return false;
    }
    
    // 通过获取用户信息来验证token
    await fetchUserProfile();
    return true;
  } catch (error) {
    console.error('Token验证失败:', error);
    return false;
  }
}

/**
 * 自动登录检查
 * 应用启动时调用，检查是否有有效的登录状态
 */
export async function autoLoginCheck() {
  try {
    if (isLoggedIn()) {
      // 验证token是否仍然有效
      const isValid = await validateToken();
      if (!isValid) {
        // Token无效，清除登录状态
        clearUserInfo();
        return false;
      }
      return true;
    }
    return false;
  } catch (error) {
    console.error('自动登录检查失败:', error);
    clearUserInfo();
    return false;
  }
}

// 用户状态枚举
export const USER_STATUS = {
  NORMAL: 0,     // 正常
  DISABLED: 1,   // 禁用
  LOCKED: 2      // 锁定
};

// 性别枚举
export const GENDER = {
  UNKNOWN: 0,    // 未知
  MALE: 1,       // 男
  FEMALE: 2      // 女
};